#include  "bsp_usart.h"

/*!  UART定义注册示例
UART_TX_GPIO_DEF(BOARD_UART,B,6,GPIO_USART0_REMAP);
UART_RX_GPIO_DEF(BOARD_UART,B,6,GPIO_USART0_REMAP);
UART_TX_DMA_DEF(BOARD_UART,DMA0,DMA_CH3);
UART_RX_DMA_DEF(BOARD_UART,DMA0,DMA_CH4);
UART_DEF(BOARD_UART,USART0,115200U,USART_PM_NONE,USART_WL_8BIT,MODE_POLL,MODE_INT);

UART_TX_GPIO_DEF(MODULE_USART,B,10,NULL);
UART_RX_GPIO_DEF(MODULE_USART,B,11,NULL);
UART_TX_DMA_DEF(MODULE_USART,DMA0,DMA_CH1);
UART_RX_DMA_DEF(MODULE_USART,DMA0,DMA_CH2);
UART_DEF(MODULE_USART,USART2,115200U,USART_PM_NONE,USART_WL_8BIT,MODE_DMA,MODE_DMA);


const void* UART_INIT_GROUP[]={&BOARD_UART,&MODULE_USART};

#define UART_INIT_SIZE  sizeof(UART_INIT_GROUP)/sizeof(void*)

*/

/**
 * @brief 初始化UART驱动
 *
 * 本函数负责初始化UART外设，包括配置GPIO、DMA（如果使用）、设置波特率、配置收发功能、字长和奇偶校验等
 *
 * @param uartx 指向UART配置结构体的指针，包含UART外设的所有配置信息
 */
void driver_uart_init(typdef_uart_struct* uartx) {
	// 使能UART外设时钟
	rcu_periph_clock_enable(uartx->rcu_uart_x);
	// 初始化UART外设
	usart_deinit(uartx->uart_x);

	// 初始化UART的RX和TX引脚
	driver_gpio_general_init(uartx->uart_rx_gpio);
	driver_gpio_general_init(uartx->uart_tx_gpio);

	// 如果UART接收模式配置为DMA
	if (uartx->uart_mode_rx == MODE_DMA) {
		// 如果接收DMA配置不为空
		if (uartx->uart_rx_dma != NULL) {
			// 初始化接收DMA配置
			driver_dma_com_init(uartx->uart_rx_dma, (uint32_t)&USART_DATA(uartx->uart_x), NULL, DMA_Width_8BIT, DMA_PERIPHERAL_TO_MEMORY);
			// 使能UART的空闲线中断，用于触发DMA接收
			usart_interrupt_enable(uartx->uart_x, USART_INT_IDLE);
		}
	}

	// 如果UART发送模式配置为DMA
	if (uartx->uart_mode_tx == MODE_DMA) {
		// 如果发送DMA配置不为空
		if (uartx->uart_tx_dma != NULL) {
			// 初始化发送DMA配置
			driver_dma_com_init(uartx->uart_tx_dma, (uint32_t)&USART_DATA(uartx->uart_x), NULL, DMA_Width_8BIT, DMA_MEMORY_TO_PERIPHERAL);
		}
	}

	// 设置UART的波特率
	usart_baudrate_set(uartx->uart_x, uartx->baudrate);
	// 使能UART接收功能
	usart_receive_config(uartx->uart_x, USART_RECEIVE_ENABLE);
	// 使能UART发送功能
	usart_transmit_config(uartx->uart_x, USART_TRANSMIT_ENABLE);
	// 设置UART的数据长度
	usart_word_length_set(uartx->uart_x, uartx->data_length);
	// 设置UART的奇偶校验方式
	usart_parity_config(uartx->uart_x, uartx->parity);

	// 使能UART外设
	usart_enable(uartx->uart_x);
}

/**
 * @brief 通过轮询方式发送数据
 *
 * 本函数使用轮询机制通过UART接口发送数据。它检查发送状态，等待发送完成，
 * 并处理超时情况。在数据发送过程中，它会逐字节检查发送缓冲区，并调用
 * 相关的硬件函数来完成数据的发送。   阻塞发送模式下，函数会一直等待发送完成。
 *
 * @param uartx UART设备结构体指针，包含UART设备的控制和状态信息
 * @param pbuff 指向待发送数据的缓冲区
 * @param length 待发送数据的长度
 * @return Drv_Err 返回发送结果，DRV_SUCCESS表示成功，DRV_ERROR表示失败
 */
Drv_Err driver_uart_poll_transmit(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	// 初始化超时计数器
	// uint64_t timeout = driver_tick;

	// // 等待发送完成或超时
	// while (uartx->uart_control.Com_Flag.Bits.SendState == 1) {
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		uartx->uart_control.Com_Flag.Bits.SendState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 准备发送数据
	uartx->uart_control.Com_Flag.Bits.SendSucess = 0;
	uartx->uart_control.Com_Flag.Bits.SendState = 1;
	uartx->uart_control.p_Send = pbuff;
	uartx->uart_control.SendSize = length;
	uartx->uart_control.SendCount = 0;

	// 逐字节发送数据
	for (uint16_t i = 0; i < length; i++) {
		if (DRV_ERROR == driver_uart_flag_wait_timeout(uartx, USART_FLAG_TBE, SET)) {
			return DRV_ERROR;
		}
		usart_data_transmit(uartx->uart_x, pbuff[i]);
		uartx->uart_control.SendCount++;
	}

	// 确保所有数据发送完成
	if (DRV_ERROR == driver_uart_flag_wait_timeout(uartx, USART_FLAG_TC, SET)) {
		return DRV_ERROR;
	}

	// 发送成功
	uartx->uart_control.Com_Flag.Bits.SendSucess = 1;
	uartx->uart_control.Com_Flag.Bits.SendState = 0;

	return DRV_SUCCESS;
}

/**
 * @brief 使用轮询方式接收UART数据
 *
 * 本函数通过轮询方式接收指定长度的数据到缓冲区中。它首先配置UART接收参数，
 * 然后在循环中等待数据接收完成。如果在接收过程中发生错误，函数将返回错误代码。
 *
 * @param uartx UART设备结构体指针，包含UART设备的控制和状态信息
 * @param pbuff 指向接收缓冲区的指针，用于存储接收到的数据
 * @param length 需要接收的数据长度
 * @return Drv_Err 接收操作的结果，DRV_SUCCESS表示成功，DRV_ERROR表示失败
 */
Drv_Err driver_uart_poll_receive(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	// 初始化接收成功标志为0
	uartx->uart_control.Com_Flag.Bits.RecSuccess = 0;
	// 设置接收进行中标志为1
	uartx->uart_control.Com_Flag.Bits.RecState = 1;
	// 设置接收缓冲区指针
	uartx->uart_control.p_Rec = pbuff;
	// 设置需要接收的数据长度
	uartx->uart_control.RecSize = length;
	// 初始化已接收数据计数为0
	uartx->uart_control.RecCount = 0;

	// 检查并清除可能的帧错误标志
	if (usart_flag_get(uartx->uart_x, USART_FLAG_ORERR)) {
		usart_flag_clear(uartx->uart_x, USART_FLAG_ORERR);
		USART_STAT0(uartx->uart_x);
		USART_DATA(uartx->uart_x);
	}

	// 循环接收数据，直到达到指定长度
	for (uint16_t i = 0; i < length; i++) {
		// 等待接收缓冲器非空标志，如果等待超时，返回错误
		if (DRV_ERROR == driver_uart_flag_wait_timeout(uartx, USART_FLAG_RBNE, SET)) {
			return DRV_ERROR;
		}
		// 从UART接收数据到缓冲区
		pbuff[i] = usart_data_receive(uartx->uart_x);
		// 更新已接收数据计数
		uartx->uart_control.RecCount++;
	}

	// 设置接收成功标志为1
	uartx->uart_control.Com_Flag.Bits.RecSuccess = 1;
	// 清除接收进行中标志
	uartx->uart_control.Com_Flag.Bits.RecState = 0;

	// 返回成功
	return DRV_SUCCESS;
}

/**
 * @brief 通过DMA传输方式发送UART数据
 *
 * 本函数使用DMA控制器将数据发送到UART，以减轻CPU负担，提高效率
 * 它首先检查当前UART是否忙于发送数据，然后配置DMA传输参数，
 * 启动DMA传输，并在传输完成后更新状态
 *
 * @param uartx UART设备结构体指针，包含UART设备的配置信息
 * @param pbuff 指向待发送数据缓冲区的指针
 * @param length 待发送数据的长度
 * @return Drv_Err 返回发送状态，如果发送成功则返回DRV_OK，否则返回DRV_ERROR
 */
Drv_Err driver_uart_dma_transmit(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	Drv_Err uart_state = DRV_ERROR;

	// 初始化超时计数器，用于防止死锁
	// uint64_t timeout = driver_tick;
	// while (uartx->uart_control.Com_Flag.Bits.SendState == 1) {
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		uartx->uart_control.Com_Flag.Bits.SendState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 配置发送状态和参数
	uartx->uart_control.Com_Flag.Bits.SendSucess = 0;
	uartx->uart_control.Com_Flag.Bits.SendState = 1;
	uartx->uart_control.p_Send = pbuff;
	uartx->uart_control.SendSize = length;
	uartx->uart_control.SendCount = 0;

	// 等待DMA传输完成
//	uart_state = driver_dma_flag_wait_timeout(uartx->uart_tx_dma, DMA_FLAG_FTF, SET);

	// 配置UART DMA传输，禁用数据发送中断
//	usart_dma_transmit_config(uartx->uart_x, USART_DENT_DISABLE);

	// 启动DMA传输
	driver_dma_start(uartx->uart_tx_dma, pbuff, length);

	// 清除UART传输完成标志
	usart_flag_clear(uartx->uart_x, USART_FLAG_TC);

	// 重新启用UART DMA传输，启用数据发送中断
//	usart_dma_transmit_config(uartx->uart_x, USART_DENT_ENABLE);
	usart_interrupt_enable(uartx->uart_x, USART_INT_TC);

	return uart_state;
}


/**
 * @brief 通过UART接口传输一个字节的数据
 *
 * 此函数负责通过特定的UART接口传输一个字节的数据。它首先检查当前是否可以发送数据，
 * 并在设定的超时时间内等待发送完成。如果在指定时间内未能完成发送，函数将返回错误。
 *
 * @param uartx 指向UART结构体的指针，包含UART通信的控制和状态信息
 * @param data 要传输的字节数据
 * @return Drv_Err 返回UART传输的状态，成功或错误
 */
Drv_Err driver_uart_transmit_byte(typdef_uart_struct* uartx, uint8_t data) {
	// 初始化超时时间为当前时间加上预设的UART超时值
	// uint64_t timeout = driver_tick;
	// // 等待发送完成或超时
	// while (uartx->uart_control.Com_Flag.Bits.SendState == 1) {
	// 	// 检查是否超时，如果超时则重置发送状态并返回错误
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		uartx->uart_control.Com_Flag.Bits.SendState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 初始化UART状态为成功
	Drv_Err uart_state = DRV_SUCCESS;
	// 重置发送成功标志
	uartx->uart_control.Com_Flag.Bits.SendSucess = 0;
	// 设置正在发送标志
	uartx->uart_control.Com_Flag.Bits.SendState = 1;

	// 等待UART发送缓冲区为空，准备发送数据
	uart_state = driver_uart_flag_wait_timeout(uartx, USART_FLAG_TBE, SET);

	// 通过UART接口发送数据
	usart_data_transmit(uartx->uart_x, data);

	// 设置发送成功标志
	uartx->uart_control.Com_Flag.Bits.SendSucess = 1;
	// 重置正在发送标志
	uartx->uart_control.Com_Flag.Bits.SendState = 0;

	// 返回UART发送状态
	return uart_state;
}

/**
 * @brief 通过DMA接收UART数据
 *
 * 本函数使用DMA方式接收UART数据，以提高数据接收的效率和减少CPU负担
 * 它首先检查UART接收状态，然后配置DMA接收，最后启动DMA传输和UART接收中断
 *
 * @param uartx UART设备结构体指针，包含UART设备的配置信息
 * @param pbuff 接收数据的缓冲区指针
 * @param length 需要接收的数据长度
 * @return Drv_Err 返回接收状态，DRV_SUCCESS表示成功，DRV_ERROR表示超时或其他错误
 */
Drv_Err driver_uart_dma_receive(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	Drv_Err uart_state = DRV_SUCCESS;
//	uint64_t timeout = driver_tick;

	// 等待UART接收完成上一次接收过程
	// while (uartx->uart_control.Com_Flag.Bits.RecState == 1) {
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		uartx->uart_control.Com_Flag.Bits.RecState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 准备开始新的接收过程
	uartx->uart_control.Com_Flag.Bits.RecSuccess = 0;
	uartx->uart_control.Com_Flag.Bits.RecState = 1;
	uartx->uart_control.p_Rec = pbuff;
	uartx->uart_control.RecSize = length;
	uartx->uart_control.RecCount = 0;

	// 检查并清除可能的UART接收错误
	if (usart_flag_get(uartx->uart_x, USART_FLAG_ORERR)) {
		usart_flag_clear(uartx->uart_x, USART_FLAG_ORERR);
		USART_STAT0(uartx->uart_x);
		USART_DATA(uartx->uart_x);
	}

	// 配置UART DMA接收为禁用状态，准备接收配置
//	usart_dma_receive_config(uartx->uart_x, USART_DENR_DISABLE);

	// 启动DMA接收
	driver_dma_start(uartx->uart_rx_dma, pbuff, length);

	// 读取UART状态和接收数据，准备接收过程
	USART_STAT0(uartx->uart_x);
	usart_data_receive(uartx->uart_x);

	// 清除UART空闲中断标志，准备接收数据
	usart_interrupt_flag_clear(uartx->uart_x, USART_INT_FLAG_IDLE);

	// 启用UART空闲中断，用于检测接收数据的结束
	usart_interrupt_enable(uartx->uart_x, USART_INT_IDLE);

	// 配置UART DMA接收为启用状态，开始接收数据
//	usart_dma_receive_config(uartx->uart_x, USART_DENR_ENABLE);

	return uart_state;
}

/**
 * @brief 通过UART接口使用中断方式发送数据
 *
 * 此函数负责通过指定的UART接口发送一串数据。它采用中断驱动的方式进行数据传输，
 * 并在数据发送成功后更新相关的状态标志。此外，该函数还包含了超时设置，如果在指定时间内
 * 未能完成数据发送，则会终止发送并返回错误。
 *
 * @param uartx 指向UART结构体的指针，包含了UART外设的配置信息
 * @param pbuff 指向待发送数据缓冲区的指针
 * @param length 待发送数据的长度
 * @return Drv_Err 返回数据发送的结果，DRV_SUCCESS表示成功，DRV_ERROR表示失败
 */
Drv_Err driver_uart_int_transmit(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	// 初始化超时计数器
	// uint64_t timeout = driver_tick;

	// // 等待直到上一次的发送完成或者超时
	// while (uartx->uart_control.Com_Flag.Bits.SendState == 1) {
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		// 如果超时，重置发送状态并返回错误
	// 		uartx->uart_control.Com_Flag.Bits.SendState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 重置发送成功标志，并设置当前状态为正在发送
	uartx->uart_control.Com_Flag.Bits.SendSucess = 0;
	uartx->uart_control.Com_Flag.Bits.SendState = 1;

	// 配置发送数据的缓冲区和长度
	uartx->uart_control.p_Send = pbuff;
	uartx->uart_control.SendSize = length;
	uartx->uart_control.SendCount = 0;

	// 清除USART的TC（传输完成）标志，准备开始新的传输
	usart_flag_clear(uartx->uart_x, USART_FLAG_TC);

	// 使能USART的TBE（发送缓冲区空）中断，开始发送数据
	usart_interrupt_enable(uartx->uart_x, USART_INT_TBE);

	// 返回成功，表示数据发送已经启动
	return DRV_SUCCESS;
}

/**
 * @brief 通过UART中断接收数据
 *
 * 此函数初始化UART接收过程，设置接收缓冲区和长度，清除可能的错误标志，并启用相应的中断
 *
 * @param uartx UART设备结构体指针，包含UART设备的配置和状态信息
 * @param pbuff 接收数据的缓冲区指针
 * @param length 需要接收的数据长度
 * @return Drv_Err 接收启动成功返回DRV_SUCCESS，否则返回DRV_ERROR
 */
Drv_Err driver_uart_int_receive(typdef_uart_struct* uartx, uint8_t* pbuff, uint16_t length) {
	// 初始化接收超时时间
	// uint64_t timeout = driver_tick;
	// // 等待接收完成或超时
	// while (uartx->uart_control.Com_Flag.Bits.RecState == 1) {
	// 	// 检查是否超时
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		// 超时处理：停止接收并返回错误
	// 		uartx->uart_control.Com_Flag.Bits.RecState = 0;
	// 		return DRV_ERROR;
	// 	}
	// }

	// 检查接收过程中是否存在溢出错误
	if (usart_flag_get(uartx->uart_x, USART_FLAG_ORERR)) {
		// 清除溢出错误标志
		usart_flag_clear(uartx->uart_x, USART_FLAG_ORERR);
		USART_STAT0(uartx->uart_x);
		USART_DATA(uartx->uart_x);
	}

	// 准备下一次接收
	uartx->uart_control.Com_Flag.Bits.RecSuccess = 0;
	uartx->uart_control.Com_Flag.Bits.RecState = 1;
	uartx->uart_control.p_Rec = pbuff;
	uartx->uart_control.RecSize = length;
	uartx->uart_control.RecCount = 0;

	// 清除空闲线中断标志，准备接收数据
	usart_flag_clear(uartx->uart_x, USART_FLAG_IDLE);
	USART_STAT0(uartx->uart_x);
	USART_DATA(uartx->uart_x);

	// 启用接收数据寄存器非空和空闲线中断，开始接收数据
	usart_interrupt_enable(uartx->uart_x, USART_INT_RBNE);
	usart_interrupt_enable(uartx->uart_x, USART_INT_IDLE);

	// 接收启动成功
	return DRV_SUCCESS;
}


/**
 * @brief 等待USART标志位达到预期状态，带有超时设置
 *
 * 该函数用于等待指定的USART标志位达到预期状态，如果在指定的超时时间内标志位未达到预期状态，则函数返回错误
 * 主要应用在USART通信中，用于确保数据的可靠传输
 *
 * @param uartx 指向USART结构体的指针，包含USART的配置信息
 * @param flag 指定需要检查的USART标志位
 * @param wait_state 期望的标志位状态，函数将等待标志位达到此状态
 * @return Drv_Err 如果标志位在超时时间内达到预期状态，返回DRV_SUCCESS；否则返回DRV_ERROR
 */
Drv_Err driver_uart_flag_wait_timeout(typdef_uart_struct* uartx, usart_flag_enum flag, FlagStatus wait_state) {
	// 记录当前时间，用于计算超时
	// uint64_t timeout = driver_tick;

	// // 循环等待标志位达到预期状态
	// while (wait_state != usart_flag_get(uartx->uart_x, flag)) {
	// 	// 检查是否发生超时，如果超时则返回错误
	// 	if ((timeout + UART_TIMEOUT_MS) <= driver_tick) {
	// 		return DRV_ERROR;
	// 	}
	// }

	// 标志位达到预期状态，返回成功
	return DRV_SUCCESS;
}

/**
 * @brief  UART中断处理函数
 * @param  uartx: UART设备结构体指针，包含UART设备的相关信息
 * @retval Drv_Err: 返回UART状态，DRV_SUCCESS表示成功，DRV_ERROR表示出错
 * @note   该函数用于处理UART设备的中断事件，包括接收数据、发送数据和错误处理
 */
Drv_Err driver_uart_int_handler(typdef_uart_struct* uartx) {
	Drv_Err uart_state = DRV_SUCCESS;

	// 检查UART接收缓冲区非空中断标志
	if (usart_interrupt_flag_get(uartx->uart_x, USART_INT_FLAG_RBNE) != RESET) {
		// 如果接收的数据量小于接收缓冲区大小，则读取数据并增加计数
		if (uartx->uart_control.RecCount < uartx->uart_control.RecSize) {
			uartx->uart_control.p_Rec[uartx->uart_control.RecCount] = usart_data_receive(uartx->uart_x);
			uartx->uart_control.RecCount++;
		} else {
			// 如果接收缓冲区已满，则接收数据但不保存，设置错误状态
			usart_data_receive(uartx->uart_x);
			uart_state = DRV_ERROR;
		}
		// 调用接收中断回调函数，如果已注册
		if (uartx->uart_rbne_callback != NULL) {
			uartx->uart_rbne_callback(uartx);
		}
		// 如果接收数据量达到预期，设置接收成功标志并重置接收状态
		if (uartx->uart_control.RecCount == uartx->uart_control.RecSize) {
			uartx->uart_control.Com_Flag.Bits.RecSuccess = 1;
			uartx->uart_control.Com_Flag.Bits.RecState = 0;
			uartx->uart_control.RecCount = 0;
		}
	}

	// 检查UART空闲线中断标志
	if (usart_interrupt_flag_get(uartx->uart_x, USART_INT_FLAG_IDLE) != RESET) {
		usart_interrupt_flag_clear(uartx->uart_x, USART_INT_FLAG_IDLE);
		USART_STAT0(uartx->uart_x);
		USART_DATA(uartx->uart_x);

		// 根据接收模式检查接收数据量是否正确
		if ( (uartx->uart_mode_rx == MODE_INT && uartx->uart_control.RecCount > 0) \
		     || (uartx->uart_mode_rx == MODE_DMA && dma_transfer_number_get(uartx->uart_rx_dma->dmax, uartx->uart_rx_dma->dma_chx) != uartx->uart_control.RecSize)) {
			uartx->uart_control.Com_Flag.Bits.RecSuccess = 1;
			uartx->uart_control.Com_Flag.Bits.RecState = 0;

			// 如果使用DMA模式，计算实际接收的数据量
			if (uartx->uart_mode_rx == MODE_DMA) {
				uartx->uart_control.RecCount = uartx->uart_control.RecSize - dma_transfer_number_get(uartx->uart_rx_dma->dmax, uartx->uart_rx_dma->dma_chx);
			}
			// 调用空闲线中断回调函数，如果已注册
			if (uartx->uart_idle_callback != NULL) {
				uartx->uart_idle_callback(uartx);
			}
		}
	}

	// 检查UART发送数据寄存器为空中断标志
	if (usart_interrupt_flag_get(uartx->uart_x, USART_INT_FLAG_TBE) != RESET) {
		// 发送数据并增加发送计数
		usart_data_transmit(uartx->uart_x, uartx->uart_control.p_Send[uartx->uart_control.SendCount]);
		uartx->uart_control.SendCount++;

		// 调用发送中断回调函数，如果已注册
		if (uartx->uart_tbe_callback != NULL) {
			uartx->uart_tbe_callback(uartx);
		}

		// 如果所有数据发送完毕，重置发送计数并禁用发送中断，启用发送完成中断
		if (uartx->uart_control.SendCount >= uartx->uart_control.SendSize) {
			uartx->uart_control.SendCount = 0;
			usart_interrupt_disable(uartx->uart_x, USART_INT_TBE);
			usart_interrupt_enable(uartx->uart_x, USART_INT_TC);
		}
	}

	// 检查UART发送完成中断标志
	if (usart_interrupt_flag_get(uartx->uart_x, USART_INT_FLAG_TC) != RESET) {
		usart_interrupt_disable(uartx->uart_x, USART_INT_TC);
		usart_flag_clear(uartx->uart_x, USART_FLAG_TC);

		// 如果DMA模式下没有数据待发送，设置发送成功标志并重置发送状态
		if ( !(uartx->uart_mode_rx == MODE_DMA && dma_transfer_number_get(uartx->uart_tx_dma->dmax, uartx->uart_tx_dma->dma_chx) != 0) ) {
			uartx->uart_control.Com_Flag.Bits.SendSucess = 1;
			uartx->uart_control.Com_Flag.Bits.SendState = 0;

			// 调用发送完成回调函数，如果已注册
			if (uartx->uart_tc_callback != NULL) {
				uartx->uart_tc_callback(uartx);
			}

			uartx->uart_control.SendCount = 0;
		}
	}

	// 检查UART接收溢出错误标志
	if (usart_flag_get(uartx->uart_x, USART_FLAG_ORERR) == SET) {
		usart_flag_clear(uartx->uart_x, USART_FLAG_ORERR);
		USART_STAT0(uartx->uart_x);
		USART_DATA(uartx->uart_x);
		uart_state = DRV_ERROR;
	}

	return uart_state;
}

















